package com.datastructures.sparsearray;

/**
二维数组转稀疏数组
稀疏数组转二维数组
将稀疏数组保存在本地磁盘中，并通过本地磁盘读取后恢复成二维数组
 **/

import java.io.*;

public class SparseArray {
    public final static String resourcePath = "C:\\Code\\DataStructures\\SparseArray\\map.data";

    //输出二维数组,,每一行是一个一维数组
    public static void printArray(int[][] array) {
        for (int[] row : array) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
    }

    //序列化：将数组保存在本地磁盘中
    public static void sparseSerialize(int[][] array){
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream(resourcePath));
            oos.writeObject(array);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //反序列化：将本地磁盘的文件输出二维数组
    public static Object sparseDSerialize(String resourcePath){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(resourcePath));
            Object arr = ois.readObject();
            return arr;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static void main(String[] args) {
        //创建棋盘（11*11二维数组）
        // 0：没有棋子，1：黑子，2：白子
        int chessArr1[][] = new int[10][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;

        //输出二维数组
        System.out.println("原始的二维数组如下：");
        printArray(chessArr1);
        System.out.println("二维数组转稀疏数组：");
        //遍历二维数组中所有有效数字的个数,并创建稀疏数组
        int count = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                }
            }
        }
        int sparseArr[][] = new int[count + 1][3];
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = count;
        //遍历二位数组，在稀疏数组中记录有效数字的行、列和数值
        //重新记录有效数字的个数，第n个有效数字对应第n行
        count = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组
        printArray(sparseArr);
        System.out.println("稀疏数组转二位数组：");
        //创建二维数组
        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        for(int i = 1 ;i<sparseArr.length;i++){
            //在二维数组中，没有被赋值的元素默认为0
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        printArray(chessArr2);

        //稀疏数组序列化
        sparseSerialize(sparseArr);
        //稀疏数组反序列化
        System.out.println("稀疏数组反序列化：");
        int[][] arr = (int[][]) sparseDSerialize(resourcePath);
        printArray(arr);
    }
}
